export namespace main {
	
	export class Account {
	    name: string;
	    platform: string;
	    version: number;
	    fullVersion: string;
	    dataDir: string;
	    key: string;
	    pid: number;
	    exePath: string;
	    status: string;
	
	    static createFrom(source: any = {}) {
	        return new Account(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.name = source["name"];
	        this.platform = source["platform"];
	        this.version = source["version"];
	        this.fullVersion = source["fullVersion"];
	        this.dataDir = source["dataDir"];
	        this.key = source["key"];
	        this.pid = source["pid"];
	        this.exePath = source["exePath"];
	        this.status = source["status"];
	    }
	}
	export class Base64Image {
	    data: string;
	    mimeType: string;
	    ext: string;
	
	    static createFrom(source: any = {}) {
	        return new Base64Image(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = source["data"];
	        this.mimeType = source["mimeType"];
	        this.ext = source["ext"];
	    }
	}
	export class File {
	    path: string;
	    modified_time: number;
	    size: number;
	
	    static createFrom(source: any = {}) {
	        return new File(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.path = source["path"];
	        this.modified_time = source["modified_time"];
	        this.size = source["size"];
	    }
	}
	export class FileStat {
	    is_dir: boolean;
	    name: string;
	    data: number;
	
	    static createFrom(source: any = {}) {
	        return new FileStat(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.is_dir = source["is_dir"];
	        this.name = source["name"];
	        this.data = source["data"];
	    }
	}
	export class Keys {
	    data_key: string;
	    img_key: string;
	
	    static createFrom(source: any = {}) {
	        return new Keys(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data_key = source["data_key"];
	        this.img_key = source["img_key"];
	    }
	}
	export class ProcessConfig {
	    type: string;
	    account: string;
	    platform: string;
	    version: number;
	    full_version: string;
	    data_dir: string;
	    data_key: string;
	    work_dir: string;
	    http_enabled: boolean;
	    http_addr: string;
	    last_time: number;
	    files: File[];
	
	    static createFrom(source: any = {}) {
	        return new ProcessConfig(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.type = source["type"];
	        this.account = source["account"];
	        this.platform = source["platform"];
	        this.version = source["version"];
	        this.full_version = source["full_version"];
	        this.data_dir = source["data_dir"];
	        this.data_key = source["data_key"];
	        this.work_dir = source["work_dir"];
	        this.http_enabled = source["http_enabled"];
	        this.http_addr = source["http_addr"];
	        this.last_time = source["last_time"];
	        this.files = this.convertValues(source["files"], File);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply___main_Account_ {
	    data: Account[];
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply___main_Account_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], Account);
	        this.error = source["error"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply_bool_ {
	    data: boolean;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_bool_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = source["data"];
	        this.error = source["error"];
	    }
	}
	export class Reply_int64_ {
	    data: number;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_int64_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = source["data"];
	        this.error = source["error"];
	    }
	}
	export class Reply_int_ {
	    data: number;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_int_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = source["data"];
	        this.error = source["error"];
	    }
	}
	export class Reply_main_Base64Image_ {
	    data: Base64Image;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_main_Base64Image_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], Base64Image);
	        this.error = source["error"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply_main_FileStat_ {
	    data: FileStat;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_main_FileStat_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], FileStat);
	        this.error = source["error"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply_main_Keys_ {
	    data: Keys;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_main_Keys_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], Keys);
	        this.error = source["error"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply_map_string_main_ProcessConfig_ {
	    data: Record<string, ProcessConfig>;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_map_string_main_ProcessConfig_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = this.convertValues(source["data"], ProcessConfig, true);
	        this.error = source["error"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice && a.map) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class Reply_string_ {
	    data: string;
	    error: string;
	
	    static createFrom(source: any = {}) {
	        return new Reply_string_(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.data = source["data"];
	        this.error = source["error"];
	    }
	}

}

